home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 1 / Meeting Pearls Vol 1 (1994).iso / amok98-106 / amok103 / identifiedtypes / identifiedtypes.dok < prev    next >
Text File  |  1993-12-05  |  8KB  |  189 lines
  1. (****************************************************************************
  2. :Program.       IdentifiedTypes.mod
  3. :Contents.      module to handle type-ids for storing data in files, ....
  4. :Author.        Richard Günther [gvm]
  5. :Address.       HeilbronnerStr.267, 72760 Reutlingen
  6. :Phone.         07121/66432
  7. :Copyright.     PublicDomain
  8. :Language.      Oberon2
  9. :Translator.    AmigaOberon v3.00d
  10. :Imports.       none
  11. :History.       V0.9 [gvm] 04-Oct-93  first implementation
  12. :History.       V1.0 [gvm] 31-Oct-93  fixed bugs
  13. :Bugs.          none known, won't perhaps work with future Compiler-Versions!
  14. ****************************************************************************)
  15.  
  16.  
  17. COPYRIGHT:  Dieses Modul darf ohne Einschränkungen in nicht kommerziellen
  18.             (Shareware ist kommerziell) Programmen verwendet werden.
  19.             Für anderweitige Verwendung ist meine schriftliche Zustimmung
  20.             nötig, setzen Sie sich bitte mit mir in Verbindung.
  21.             Dieses Modul darf nur in seinem vollen Umfang (Dokumentation,
  22.             Quellcode) und nur zum Selbstkostenpreis (maximal 5 Deutsche Mark)
  23.             vertrieben werden.
  24.  
  25.   Ich übernehme keine Garantie für die Fehlerfreiheit dieses Moduls. Die ver-
  26.   wendung der Routinen ist auf eigene Gefahr, für eventuelle Schäden an Daten
  27.   oder Programmen wird keine Haftung übernommen!
  28.  
  29.  
  30. INHALT: Dieses Modul verwaltet Typen und bietet eine Art Typ-Typ, anhand
  31.         dem sich eine Variable identifizieren und reproduzieren kann
  32.         (weiterlesen!).
  33.         Dadurch werden in eingeschränkter Weise die Funktionen von
  34.         Konstruktoren (C++/BorlandPascal(R)) und Metaklassen (Smalltalk)
  35.         nachgebildet. Schön wäre es natürlich wenn ich dies nicht durch
  36.         umständlichen Code (INLINE..) selbst erledigen müßte, sondern
  37.         wenn das Konzept der Konstruktoren und Destruktoren sowie
  38.         der Metaklassen (in Oberon wohl besser (?) als Typ-Typ zu bezeichnen)
  39.         in den Sprachumfang von AmigaOberon aufgenommen würde.
  40.         Der Typ-Typ entspräche dem Typdescriptor, dem dann ein eigener,
  41.         fest eingebauter Typ spendiert werden müßte, der sich wie ein
  42.         Record verhält, also man auf ihn Methoden anwenden darf, sowie
  43.         ein oder mehrere benutzerdefinierbare Felder enthält
  44.         (für den ID-String).
  45.         Ich werde trotzdem daran weiterarbeiten, auch einen Destruktor zu
  46.         implementieren (Puh, noch mehr INLINE...).
  47.  
  48.  
  49.  
  50. PROZEDUR-BESCHREIBUNGEN:
  51.  
  52.   Jeder Datentyp, der von den folgenden Möglichkeiten gebrauch machen will,
  53.   muß als Erweiterung von IdentifiedTypes.IDENTDesc definiert werden.
  54.   IDENTDesc ist wiefolgt definiert:
  55.  
  56.     TYPE  IDENT = POINTER TO IDENTDesc;
  57.           IDENTDesc = RECORD (BasicTypes.ANYDesc) END;
  58.  
  59.   Mit der Definition eines Typen ist es allerdings nicht getan, Sie müssen
  60.   ihre Datentypen IdentifiedTypes bekannt machen. Dies geschieht entweder
  61.   mittels der Prozedur AddManualCreateType oder mittels AddAutoCreateType.
  62.   AddManualCreateType ist die universellere Routine, sie können Sie auf
  63.   alle Typen anwenden. AddAutoCreateType können Sie nur auf solche Typen
  64.   anwenden, die in ihrer Struktur nur einen Typ-Descriptor enthalten, d.h.
  65.   Records, die innerhalb ihrer Definition Records (nicht Pointer auf Records!)
  66.   enthalten, dürfen Sie hier nicht verwenden!!!
  67.   Für AddManualCreateType müssen Sie (das ist der Nachteil) eine Prozedur
  68.   angeben, die eine Variable des Typs erzeugt (s.u.). AddManualCreateType
  69.   benötigen Sie daher auch, wenn es mit der Speicherallozierung für die
  70.   Variable nicht getan ist, sondern noch Strukturelemente initialisiert
  71.   werden müssen.
  72.  
  73.  
  74.   PROCEDURE AddManualCreateType(name: ARRAY OF CHAR;
  75.                                 typedesc: SYSTEM.ADDRESS;
  76.                                 creator: CreatorProc
  77.                                 ): IDENTManualCreateIdentifier;
  78.     Bei name geben Sie bitte eine Charakteristische Bezeichnung für den Typ
  79.     an, momentan werden die 8 ersten Zeichen berücksichtigt. (Fehlende
  80.     Zeichen werden mit Null-Bytes aufgefüllt)
  81.     Bei typedesc geben Sie bitte den Typ-Descriptor des Typs an (mittels
  82.     SYSTEM.TYPEDESC(Typ)).
  83.     Bei creator geben Sie bitte eine Prozedur der folgenden Form an:
  84.       CreatorProc* = PROCEDURE (): IDENT;
  85.     Diese Prozedur sollte eine Variable des Typs erzeugen und zurückgeben.
  86.     Als Rückgabe erhalten Sie den Pointer auf eine ID-Struktur, wenn er
  87.     NIL ist, ist ein Fehler aufgetreten. In der Regel benötigen Sie diesen
  88.     Pointer nicht mehr.
  89.  
  90.  
  91.   PROCEDURE AddAutoCreateType(name: ARRAY OF CHAR;
  92.                               exampleVar: IDENT
  93.                               ): IDENTAutoCreateIdentifier;
  94.     Bei name geben Sie bitte eine Charakteristische Bezeichnung für den Typ
  95.     an, momentan werden die 8 ersten Zeichen berücksichtigt. (Fehlende
  96.     Zeichen werden mit Null-Bytes aufgefüllt)
  97.     Bei exampleVar geben Sie bitte eine Variable des Typs an.
  98.     Als Rückgabe erhalten Sie den Pointer auf eine ID-Struktur, wenn er
  99.     NIL ist, ist ein Fehler aufgetreten. In der Regel benötigen Sie diesen
  100.     Pointer nicht mehr.
  101.  
  102.  
  103.   Über die ID-Struktur haben Sie Zugriff auf folgende Methoden:
  104.  
  105.     PROCEDURE (id: IDENTIdentifier) Create(): IDENT;
  106.       erzeugt eine Variable des Typs in der Typ-Typ-Variable id.
  107.  
  108.   Zugriff auf die ID-Struktur erhalten Sie auch über
  109.  
  110.     PROCEDURE FindIDENTIdentifier(name: ARRAY OF CHAR): IDENTIdentifier;
  111.       Diese Prozedur gibt die zu name gehörige ID-Struktur zurück, sie
  112.       entspricht der, die Sie beim Aufruf von AddAuto/ManualCreateType
  113.       als Ergebnis erhalten.
  114.  
  115.  
  116.  
  117.   Folgende Methoden sind dann für die Variablen der angemeldeten Typen
  118.   definiert:
  119.  
  120.     PROCEDURE (var: IDENT) CreateIDENTOfSameType*(): IDENT;
  121.       erzeugt eine Variable des gleichen Typs wie var.
  122.  
  123.  
  124.     PROCEDURE (var: IDENT) Copy*(dest: IDENT);
  125.       kopiert die Daten von var nach dest.
  126.       Um diese Methode zu benutzen muß für jeden Typ die Methode Copy
  127.       wiefolgt definiert werden:
  128.  
  129.         z.B.  PROCEDURE (var: Haus) Copy*(dest: IDENT);
  130.               BEGIN
  131.                 var.Copy^(dest);    (* <--- Wichtig!!!! *)
  132.                 IF dest IS Haus THEN
  133.                   lokale daten kopieren...
  134.                 END;
  135.               END;
  136.  
  137.  
  138.     PROCEDURE (var: IDENT) Duplicate*(): IDENT;
  139.       erstellt eine Kopie von var. Dazu müssen Copy-Methoden definiert
  140.       sein (s.o.).
  141.  
  142.  
  143.     PROCEDURE (t: IDENT) Write*(VAR to: FileSystem.File): BOOLEAN;
  144.       schreibt die Daten der Variable t und den bei name angegebenen
  145.       Typ-ID-String in die Datei to. Liefert TRUE, wenn alles ok war.
  146.       Um diese Methode zu benutzen muß für jeden Typ die Methode Write
  147.       wiefolgt definiert werden:
  148.  
  149.         z.B.  PROCEDURE (var: Haus) Write*(VAR to: FileSystem.File): BOOLEAN;
  150.               BEGIN
  151.                 RETURN var.Write^(to) AND      (* <--- Wichtig!!!! *)
  152.                        FileSystem.Write(to, ...lokale Daten... );
  153.               END;
  154.  
  155.  
  156.     PROCEDURE (t: IDENT) Read*(VAR from: FileSystem.File): BOOLEAN;
  157.       liest die Daten aus from in die Variable t ein. Liefert TRUE, wenn
  158.       alles ok war. Um diese Methode zu benutzen muß für jeden Typ die
  159.       Methode Read wiefolgt definiert werden:
  160.  
  161.         z.B.  PROCEDURE (var: Haus) Read*(VAR from: FileSystem.File): BOOLEAN;
  162.               BEGIN
  163.                 RETURN var.Read^(from) AND      (* <--- Wichtig!!!! *)
  164.                        FileSystem.Read(from, ...lokale Daten... );
  165.                                       (* gleiche Reihenfolge wie bei Write! *)
  166.               END;
  167.  
  168.  
  169.     PROCEDURE ReadNext*(VAR from: FileSystem.File): IDENT;
  170.       dies ist wohl die Prozedur, die Sie zum lesen verwenden werden. Sie
  171.       liest den nächsten Datensatz aus from aus und liefert einen Pointer
  172.       auf die in from abgelegte Struktur.
  173.       Wenn ReadNext NIL zurückgibt, ist entweder das Dateiende erreicht,
  174.       es trat ein Lesefehler auf, oder ein unbekannter Datensatz folgt.
  175.       (Für nähere Fehlerbestimmung interpretieren Sie das Feld from.status)
  176.  
  177.  
  178.  
  179.   Ein ausführliches Beispielprogramm finden Sie auf dieser Diskette.
  180.   (ein Teil eines CAD-Programms, CadTypen und CadSaveLoad, sowie ein
  181.    Testmodul)
  182.  
  183.   Weitere (Un-)Klarheiten können Sie durch die Lektüre des Quelltextes
  184.   (man ignoriere die Zahlreichen INLINES...) beseitigen.
  185.  
  186.  
  187.       Für Fragen und Anregungen stehe ich gerne zur Verfügung.
  188.  
  189.